ASP Advantage 1994 2nd Q2

home *** CD-ROM | disk | FTP | other *** search

/ ASP Advantage 1994 2nd Q2 / The Association of Shareware Professionals - The Official ASP Advantage (2nd Quarter)(1994).bin / files / progming / kfs / kfs.doc < prev next >

Wrap

Text File | 1994-02-15 | 67.8 KB | 2,646 lines

KEYED FILE SYSTEM - User's Guide Version 2.0 (DOS and OS/2 1.x) (c) 1993 APT Computer Solutions, Inc. Table of Contents Introduction 1 System Components and Requirements 2 System Requirements 2 Keyed File System Components 2 Keyed File System Restrictions 2 Including KFS Routines in Your Program 4 What Are Keyed Files 5 Keyed File System Functions 7 The File Information Structure 8 Parameters to Keyed File System Functions 10 Keyed File System Functions 11 KFS_Add 11 KFS_Close 13 KFS_Create 14 KFS_Delete 16 KFS_Open 18 KFS_Read 19 KFS_ReadFirst 20 KFS_ReadGen 21 KFS_ReadGenNumeric 23 KFS_ReadNext 25 KFS_Replace 27 Interdependencies of the KFS operations 29 Special Processing 30 KFS_Small_PTR 30 KFS_Numeric_Key 30 KFS_Ignore_Case 31 Programming Hints and Tips 32 Data Recovery 34 Appendix A - Keyed File System Return Codes 35 Appendix B - File Recovery Example 37 3 Introduction The Keyed File System is a set of routines that allow you to write programs in C to build and maintain databases on a PC that are logically organized by a user defined key. Records can be read or written directly using an alphabetic or numeric key. An alphabetic key can be a string consisting of any combination of ASCII characters up to 32,767 characters in length. You may also have 4 byte signed numeric keys contained in the normal Intel 80x86 long integer format. Note that a database may have alpha- betic keys or numeric keys but not both (however, see "Programming Hints & Tips" for hints about combining keys). The Keyed File System uses normal DOS and OS/2 functions to create and maintain its databases. Therefore, records may be of any length supported by the DOS or OS/2 operating systems and can be created using the FAT or HPFS (OS/2 only) file systems. Files may be created on floppy or hard disks, although, as might be expected, hard disk files will provide better performance. KFS databases may be moved or copied using normal DOS or OS/2 commands (such as COPY) as long as both file components are moved together (see "Copying Files"). Additionally, databases built using the KFS functions on one operating system are com- patible with databases built using the KFS functions on the other operating system. Thus, databases built by programs run- ning under DOS may be subsequently used by programs running under OS/2. The Keyed File System supports most operations normally associ- ated with keyed files: * Direct reading and writing of records by key. * Sequential reading of records in key sequence. * Deleting of records by key. * Reading records using a partial key. 4 System Components and Requirements System Requirements The minimum system required to run programs that use the Keyed File System are: * OS/2 1.2 or higher, or DOS 3.3 or higher. * Approx. 180K of disk space including sample programs and utilities. * Microsoft C compiler and libraries, version 6.0 (OS/2 and DOS) or 7.0 (DOS only). Keyed File System Components KFS.H - The header file for use in C programs that want to use KFS functions. KFSMSC6O.LIB - A lib used at linkedit time to include the KFS functions when building OS/2 programs written in Microsoft C Version 6.0. KFSMSC6D.LIB - A lib used at linkedit time to include the KFS functions when building DOS programs written in Microsoft C Version 6.0. KFSMSC7.LIB - A lib used at linkedit time to include the KFS functions when building DOS programs written in Microsoft C Version 7.0. KFSSAMP.C - A sample program that builds a KFS database from a sequential file and then uses most of the functions available in KFS. KFSSAMP.DAT - The sequential input file to the KFSSAMP program. KFSSAMP.MAK - A sample make file for KFSSAMP.C. Keyed File System Restrictions The following restrictions apply to KFS databases: * Databases must contain fixed length records. * Each record must be at least 5 bytes in length. * Numeric keys must be 4 bytes in length but alphabetic keys may be up to 32767 characters in length. * Duplicate keys are not allowed (see "Programming Tips and Techniques"). * The path and file name specified during KFS_Create or KFS_Open for a KFS database cannot be longer than 63 bytes. 5 * Files cannot be created using KFS_Open, you must use KFS_Create to create a new file and KFS_Open after a file exists. * Two databases with the same "base" name cannot exist in the same directory even if the file extensions are different. That is KFS databases with the base names of MYFILE.001 and MYFILE.002 cannot exist in the same directory, but the names MYFILE1.XXX and MYFILE2.XXX are OK. This is explained further in the section "What Are Keyed Files". * You cannot name a KFS database using the extension of .PTR. Thus MYFILE.PTR is invalid. This is also explained in the "What Are Keyed Files" section. 6 Including KFS Routines in Your Program To include the KFS routines in your C program requires three steps: 1. Include the KFS.H header file at the beginning of your program source. For example: #include <KFS.H> 2. Define any keyed files using the KFS_FILEINFO typedef. For example: KFS_FILEINFO keyedfile; 3. Include the appropriate KFS---.LIB file when linking your program. For example, to link a DOS program compiled with MS/C version 6.0 would be: LINK myprog,,,KFSMSC6D; For a complete example of a program using some KFS functions, look at the KFSSAMP.C file included with this package. 7 What Are Keyed Files Keyed File System databases are actually composed of two files, an index file and a data file. These two files work together to provide you with direct access of a record by key while keeping the records in a logical keyed sequence. The name of the data file is the same as the name of the database and is specified by the programmer when the KFS database is created (using the KFS_Create function). This may be any valid DOS or OS/2 file name. The index file is automatically given the same base name you specified for the database but with an extension of .PTR. For example, specifying a name of CUSTOMER.DAT for a database automatically causes the creation of an index file with the name of CUSTOMER.PTR. This leads to two restrictions in the Keyed File System: 1) You cannot name a database using an extension of .PTR. 2) You cannot have two databases in the same directory with the same base name since this would result in an attempt by KFS to create duplicate .PTR files. For example, MYFILE.001 and MYFILE.002 would both result in KFS attempting to cre- ate an index file named MYFILE.PTR. Because these two files work together they must remain physi- cally in the same directory. Therefore, if the Keyed File System database is moved, both the data and index files must be moved together. The format and content of the index file is determined by the Keyed File System, while the format and content of the data file is determined by you when the database is created. When you create a Keyed File System database you must tell the Keyed File System how large each record in the database will be (KFS_recsize), where the key begins in the record (KFS_keypos), and how long the key is (KFS_keylen). Note that the Keyed File System only supports fixed length records (ie. each record in the database is the same length). The Keyed File System requires that databases are either created or opened before they are used, and that they are closed before the program terminates. With any file system, if a program ter- minates abnormally without closing files (such as a system crash because of a power failure) and file buffering is being used (such as is available with HPFS or DOS lazy writing), data that has been "written" by the program but waiting in an output buffer to be physically written to disk may be lost. The Keyed File System makes every attempt to minimize the impact of such a system failure, but since it does utilize two files working together, there are rare times this loss of data may result in the database becoming unusable. Thus special care should be taken by your application user to properly back up the data and index files making up each KFS database. Also, see the section on "Data Recovery" for an example of how to recover a damaged KFS database. 8 Keyed File System Functions The Keyed File System is a set of 11 routines that provide you with the basic functions required for keyed record access on the PC. These functions are: KFS_Add Adds a new record to a KFS database. The key of the record being added must not already exist in the database. KFS_Close Close an open KFS database. KFS_Create Create and open a new KFS database. The database must not already exist. KFS_Delete Deletes the record from a KFS database that has the key specified. KFS_Open Open an existing KFS database. KFS_Read Read a record from an open KFS database by key. KFS_ReadFirst Reads the first logical record in a KFS database. KFS_ReadGen For databases with alphabetic keys only. Read a record from an open KFS database using a partial key. If no records match the partial key, the next record in sequence after the key requested is returned in the user area and a code of KFS_Key_Not_Found is returned in KFS_rc. KFS_ReadGenNumeric For databases with numeric keys only. Read a record from an open KFS database. If the requested key is not found, the next record in sequence after the key requested is returned in the user area and a return code of KFS_Key_Not_Found is returned in KFS_rc. KFS_ReadNext Reads the record in a KFS database that is the next record after the key specified. KFS_Replace Replaces the record in a KFS database that has the same key as the one specified. A record with this key must exist in the database. 9 The File Information Structure In order to use the Keyed File System routines, you must provide the KFS functions with a File Information Structure for each database you are going to use in your program. This is a control structure (similar to the C "FILE" typedef) that includes such information about the database as the database name, key length, location of the key within the record, and a return code field for checking the result of KFS operations, as well as control fields used by the KFS functions themselves. Once the database is opened, this structure should not be modified by the appli- cation since this may damage the control information used by the KFS functions and the integrity of the database may be compro- mised. There is a C typedef named KFS_FILEINFO for this structure defined in the KFS.H header file provided with the system. Also present in this header file are the C prototypes for the KFS functions and the definitions of the KFS return codes. To create a KFS database (using the KFS_Create operation), you must provide several important pieces of information about the database. This is done by placing the appropriate values in the following fields in the File Information Structure defined for the file: KFS_filename Required for KFS_Create or KFS_Open, this field must contain the name of the database being created or opened. This is a DOS or OS/2 file specification that includes drive, path, and database name. As mentioned before the Keyed File System actually creates (or opens) two files for any KFS database and if these files are moved, both must be move to the same loca- tion (ie. subdirectory or floppy disk). The first file will have the name you specify here, while the second file will have the same base name as the database you specified but a qualifier of .PTR. KFS_keypos KFS_Create only. This is the position of the key within the record. This position is relative to 0. That is, if the key begins in the first position of the record, 0 is placed here by the programmer. If the key begins in the 5th position of the record, 4 is put here. KFS_keylen KFS_Create only. This is the length of the key in the record. For example, if the key went from position 5 through position 10 (ie. 6 characters long) in the data record, 6 would be placed here. For numeric keys, this field is ignored. 10 KFS_recsize KFS_Create only. Place the total size of each data record, including the key in this field. KFS_flags KFS_Create only. These flags specify any special pro- cessing required for the database. The options available to you are normal pointer file, small pointer file, numeric keys, and ignore case. These options are discussed further in the section "Special Processing". Once a KFS database is created, it may be subsequently used by simply specifying the name of the database in the KFS_filename field of the File Information structure and using KFS_Open to open the database. The remaining information about the database (ie. KFS_keypos, KFS_keylen, KFS_recsize, and KFS_flags) is stored with the database when it is created. Upon the completion of a KFS operation, the success or failure of the operation is determined by checking the return code pro- vided in the database's KFS_FILEINFO field KFS_rc. The valid return codes are defined in the KFS.H header file and are docu- mented in Appendix A of this User's Guide. 11 Parameters to Keyed File System Functions The are 11 application interfaces that can be called to perform operations on databases with the Keyed File System. These operations require 1, 2, or 3 parameters depending on the func- tion desired. The first parameter to all of the KFS functions is always the address of the KFS File Information structure (KFS_FILEINFO) for the desired database. As mentioned before, once a database is created or opened this structure should not be changed by the programmer since it is used by the database system to keep track of current information about the database. It is also used to provide feedback to the programmer about the requested opera- tion. The second parameter is necessary for the functions that will be reading data from or writing data to a KFS database. This parameter is the address of an area large enough to contain a record from the database (that is, at least KFS_recsize in length). When a key is required by a specific KFS operation, the system expects the key to be in this area at the same relative position, and with the same length, as the key in a record in the database. For example, to read a record with the key "ABCDE" for a database whose KFS_keypos = 3, KFS_keylen = 5, and KFS_recsize = 80 means that the second parameter would be the address of an area at least 80 bytes in length that contains "ABCDE" in the 4th, 5th, 6th, 7th, and 8th bytes (ie. ...ABCDE..). The third parameter is only required on the KFS_ReadGen function and is the length of the portion of the key provided. This parameter is discussed further in the discussion of KFS_ReadGen. The following program segment illustrates how the above param- eters would be specified for a typical KFS function call: #include <kfs.h> KFS_FILEINFO file1; char recarea[100]; strcpy(file1.KFS_filename, "C:\\MYDIR\\MYFILE.DAT"); KFS_Open(&file1); if (file1.KFS_rc != KFS_OK) printf("Error opening file1\n"); strcpy(&recarea[file1.KFS_keypos], "A k"); KFS_ReadGen(&file1, (void *)recarea, 3); For further examples, see the description of the individual KFS functions and the KFSSAMP.C program provided as part of this package. 12 Keyed File System Functions In the description of the following functions the KFS_File_Error is a general error caused by an "unknown error" returned from the operating system and is possible for all functions. KFS_Add(fs, area) Add a data record to a database. Parameters KFS_FILEINFO *fs A pointer to a KFS file structure. void *area A pointer to a data area containing the record to be added. The key to be added must be at KFS_keypos of this area before the operation is issued. Description Add a record to the database. Another record with this key must not already exist in the database. Required Fields KFS_filename Contains the name of an open database where the record is to be added. 13 Example /* Add a record to a KFS file */ #include <kfs.h> KFS_FILEINFO file1; typedef struct m { int f1; int f2; char mykey[7]; char filler[89]; } MYSTRUCT; MYSTRUCT inarea; strcpy(file1.KFS_filename, "C:\\MYDIR\\NUMFILE.DAT"); KFS_Open(&file1); if (file1.KFS_rc != KFS_OK) printf("Error opening file1\n"); strcpy(&inarea.mykey, "Newkey"); inarea.f1 = 0; /* Just some data in record */ inarea.f2 = 15; /* Just some data in record */ KFS_Add(&file1, (void *)&inarea); switch (file1.KFS_rc) { case KFS_Key_Already_Exists : printf("Key already in file"); case KFS_OK: break; default: printf("Error adding record"); } Possible KFS_rc Values KFS_OK The record was added successfully. KFS_Key_Already_Exists A record with the same key as the record being added already exists in the database. The operation is ignored. KFS_File_Error An unknown error occurred when attempting to add a record to a KFS database. KFS_No_Space_On_Disk There was not enough space on the disk containing the KFS file to contain another data and pointer record. 14 KFS_Close(fs) Close a database. Parameters KFS_FILEINFO *fs A pointer to a KFS file structure. Description Close a database. The database must then be opened before further processing can occur. Required Fields KFS_filename Contains the name of an opened database. Example /* Close a KFS file */ #include <kfs.h> KFS_FILEINFO file1; . . KFS_Close(&file1); Possible KFS_rc Values KFS_OK The database was closed successfully. 15 KFS_Create(fs) Create a new, empty database and open it. Parameters KFS_FILEINFO *fs A pointer to a KFS file structure. Description Create an empty database from the information supplied in the KFS_FILEINFO structure. At the conclusion of a suc- cessful operation the database is opened and may be used without the need to call the KFS_Open function. If a data- base already exists with this name, an error is returned. Required Fields KFS_keypos Contains the position of the key in the records of the new database. This position is relative to 0. KFS_keylen Contains the length of the key. KFS_recsize Contains the size of each of the keyed records to be built. KFS_filename Contains the name of the database to be created. If the name has a qualifier, it cannot be PTR. Also, the base portion of the name cannot be the same as any other database even if the qualifiers are unique. KFS_flags Specifies some additional information about the data- base (See the "Special Processing" section for more discussion of these options). The valid settings for this field are: KFS_Normal_PTR The normal pointer file organization is used. This results in the initial allocation of the .PTR file of about 8K but results in good performance for large databases. KFS_Small_PTR The organization of the pointer file will be changed to save space on the initial allo- cation of the database. This option should be specified only when the database will be a small one since larger databases having this option are slower than for databases created with KFS_Normal_PTR. KFS_Numeric_Keys The keys in the database will be numeric keys stored in the Intel long integer for- mat. This option also implies a small pointer file. 16 KFS_Ignore_Case The case of the keys in the database is ignored. That is, a key of "ABCDE" and "ab- cde" will be treated as the same key. Example /* Create and open a KFS file with alphabetic keys starting */ /* in the 5th position of the record and 7 bytes long */ #include <kfs.h> KFS_FILEINFO file1; char recarea[100]; file1.KFS_flags = KFS_Normal_PTR; file1.KFS_keypos = 4; file1.KFS_keylen = 7; file1.KFS_recsize = 100; strcpy(file1.KFS_filename, "C:\\MYDIR\\MYFILE.DAT"); KFS_Create(&file1); if (file1.KFS_rc != KFS_OK) printf("Error creating file1\n"); Possible KFS_rc Values KFS_OK The database was created successfully. KFS_Keyed_File_Already_Exists A database with this name already exists. KFS_Invalid_File_Name The file name and associated path name is longer than 63 characters. KFS_PTR_File_Open_Error An unknown error occurred while attempting to open the PTR file associated with the database. This error can occur if there is not enough space on the disk to allocate the pointer file or if a .PTR file by this name already exists. KFS_Data_File_Open_Error An unknown error occurred while attempting to open the data file associated with the database. 17 KFS_Delete(fs, area) Delete a record from the database. Parameters KFS_FILEINFO *fs A pointer to a KFS file structure. void *area A pointer to a data area containing the key of the record to be deleted. This key must be placed at KFS_keypos of this area before the operation is issued. Description Delete a record from the database. Required Fields KFS_filename Contains the name of an opened database. area The data area pointed to must contain the key of the record being deleted beginning in KFS_keypos of the area. Example /* Add a record to a KFS file */ #include <kfs.h> KFS_FILEINFO file1; typedef struct m { int f1; int f2; char mykey[7]; char filler[89]; } MYSTRUCT; MYSTRUCT inarea; strcpy(file1.KFS_filename, "C:\\MYDIR\\NUMFILE.DAT"); KFS_Open(&file1); memset(&inarea.mykey, ' ', sizeof(inarea.mykey)); strcpy(&inarea.mykey, "Dkey"); KFS_Delete(&file1, (char *)&inarea); switch (file1.KFS_rc) { case KFS_OK: break; case KFS_No_Space_On_Disk: printf("Not enough space on disk to add record\n"); break; default: printf("Error adding record\n"); } Possible KFS_rc Values - KFS_OK The record was deleted successfully. 18 KFS_Key_Not_Found A record with the key specified was not found. The operation is ignored. KFS_No_Space_On_Disk There is not enough space on the disk containing the KFS database to add a record. 19 KFS_Open(fs) Open an existing database. Parameters KFS_FILEINFO *fs A pointer to a KFS file structure. Description Open an existing database for processing. All databases must be opened before any processing may be done on those databases. Required Fields KFS_filename Contains the name of an existing database to be opened. Example /* Open a KFS file */ #include <kfs.h> KFS_FILEINFO file1; char recarea[100]; strcpy(file1.KFS_filename, "C:\\MYDIR\\MYFILE.DAT"); KFS_Open(&file1); if (file1.KFS_rc != KFS_OK) printf("Error opening file1\n"); Possible KFS_rc Values KFS_OK The database was opened successfully. KFS_Keyed_File_Does_Not_Exist The database does not exist. KFS_Invalid_File_Name The database name and associated path name is longer than 63 characters. KFS_PTR_File_Open_Error An unknown error occurred while attempting to open the PTR file associated with the database. KFS_Data_File_Open_Error An unknown error occurred while attempting to open the data file associated with the database. 20 KFS_Read(fs, area) Read a record by key from the database. Parameters KFS_FILEINFO *fs A pointer to a KFS file structure. void *area A pointer to a data area where the requested record will be read. The key to be read must be placed at KFS_keypos of this area before the operation is issued. Description Read a record by key from a database. Required Fields KFS_filename Contains the name of an open database. area The data area pointed to must contain the key of the record being read beginning at position KFS_keypos. Example /* Read a KFS file by key (keypos=4, keylen=7) */ #include <kfs.h> KFS_FILEINFO file1; char recarea[100]; strcpy(file1.KFS_filename, "C:\\MYDIR\\MYFILE.DAT"); KFS_Open(&file1); if (file1.KFS_rc != KFS_OK) printf("Error opening file1\n"); memset(recarea, ' ', sizeof(recarea)); /* Note - we kept the terminating NULL as part of the key */ strcpy(&recarea[file1.KFS_keypos], "A key"); KFS_Read(&file1, (void *)recarea); if (file1.KFS_rc != KFS_OK) printf("Error reading keyed record from file1\n"); Possible KFS_rc Values KFS_OK The record was read successfully. KFS_Key_Not_Found A record with the key specified was not found. The operation is ignored. 21 KFS_ReadFirst(fs, area) Read the first record in keyed sequence in the database. Parameters KFS_FILEINFO *fs A pointer to a KFS file structure. void *area A pointer to a data area where the first record in the KFS database will be read. Description Read the first record from a database. The record with the lowest key will be read and placed in the data area. Required Fields KFS_filename Contains the name of an open database. Example /* Read the all of the records sequentially from a file */ #include <kfs.h> KFS_FILEINFO file1; char recarea[100]; strcpy(file1.KFS_filename, "C:\\MYDIR\\NUMFILE.DAT"); KFS_Open(&file1); if (file1.KFS_rc != KFS_OK) printf("Error opening file1\n"); KFS_ReadFirst(&file1, recarea); if (file1.KFS_rc != KFS_OK) printf("Error"); Possible KFS_rc Values - KFS_OK The record was read successfully. KFS_Keyed_File_Empty No records were found in the database. The operation is ignored. 22 KFS_ReadGen(fs, area, length) Read a record using a partial key. Parameters KFS_FILEINFO *fs A pointer to a KFS file structure. void *area A pointer to a data area where the requested record will be read. The partial key to be used must be placed at KFS_keypos of this area before the operation is issued. int length The length of the partial key at KFS_keypos. If the length specified is 0, the first record in the data- base is read.This length must be less than or equal to KFS_keylen. Description Read the first record in the database whose first portion matches that of the partial key supplied. If no record matches the partial key, the next logical record in the database is returned. Required Fields KFS_filename Must contain the name of an open database. area The data area pointed to must contain the key of the record being read. Example /* Read a KFS file by partial key (keypos=4, keylen=7) */ #include <kfs.h> KFS_FILEINFO file1; char recarea[100]; strcpy(file1.KFS_filename, "C:\\MYDIR\\MYFILE.DAT"); KFS_Open(&file1); if (file1.KFS_rc != KFS_OK) printf("Error opening file1\n"); strcpy(&recarea[file1.KFS_keypos], "A k"); KFS_ReadGen(&file1, (void *)recarea, 3); if (file1.KFS_rc == KFS_Key_Not_Found) printf("We had no key match but got the next key\n"); else if (file1.KFS_rc == KFS_OK) printf("We got a record with a key starting with 'A k'"); Possible KFS_rc Values - KFS_OK The partial key matched an existing record and this record was read successfully. KFS_Key_Not_Found 23 No record with a key that matched the partial key specified was found. The next logical record in the database is returned. KFS_EOF The partial key requested could not be found and the next position in the database was end of file. KFS_Key_Length_Invalid A length greater than KFS_keylen was supplied in the parameter list. KFS_Invalid_Request A KFS_ReadGen operation was attempted on a database with numeric keys. 24 KFS_ReadGenNumeric(fs, area) Read a numeric record, return the next record if not found. Parameters - KFS_FILEINFO *fs A pointer to a KFS file structure. void *area A pointer to a data area where the requested record will be read. A numeric key must be placed in KFS_keypos of this area prior to performing the operation. Description If a record in the database matches the key specified it is read and placed in the data area. KFS_OK is then returned. If no record matches the numeric key, then the next record in the database is returned with a return code of KFS_Key_Not_Found. Required Fields KFS_filename Contains the name of an open database. area The data area pointed to must contain a numeric key at KFS_keypos. Example /* Read a KFS file by numeric key (keypos=4) */ #include <kfs.h> KFS_FILEINFO file1; typedef struct m { int f1; int f2; long mykey; char filler[92]; } MYSTRUCT; MYSTRUCT inarea; strcpy(file1.KFS_filename, "C:\\MYDIR\\NUMFILE.DAT"); KFS_Open(&file1); if (file1.KFS_rc != KFS_OK) printf("Error opening file1\n"); inarea.mykey = 1000; KFS_ReadGenNumeric(&file1, (void *)inarea); if (file1.KFS_rc == KFS_Key_Not_Found) printf("There was no key 1000 but got the next key\n"); else if (file1.KFS_rc == KFS_OK) printf("We got the record with key 1000"); Possible KFS_rc Values KFS_OK The record was read successfully. 25 KFS_Key_Not_Found No record with a key that matched the key specified was found. The next logical record in the database is returned. KFS_EOF The partial key requested could not be found and the next position in the database was at end of file. 26 KFS_ReadNext(fs, area) Read the next record in keyed sequence in the database. Parameters KFS_FILEINFO *fs A pointer to a KFS file structure. void *area A pointer to a data area where the requested record will be read. The key placed at KFS_keypos of this area must be the key of the record before the record desired. Description Read the next logical record from a database. The record with the next highest key after the key specified in the data area will be read. The user must provide the key of the previous record in KFS_keypos of area. This allows the user to read all records in a database with a succession of KFS_ReadNext functions. Required Fields KFS_filename Contains the name of an open database. area Contains the key of the record previous to the one to be read. Example /* Read the all of the records sequentially from a file */ #include <kfs.h> KFS_FILEINFO file1; typedef struct m { int f1; int f2; char mykey[7]; char filler[89]; } MYSTRUCT; MYSTRUCT inarea; strcpy(file1.KFS_filename, "C:\\MYDIR\\NUMFILE.DAT"); KFS_Open(&file1); if (file1.KFS_rc != KFS_OK) printf("Error opening file1\n"); KFS_ReadFirst(&file1, (void *)&inarea); while (file1.KFS_rc != KFS_EOF) { KFS_ReadNext(&file1, (void *)&inarea); if (file1.KFS_rc != KFS_OK) printf("Error"); } KFS_Close(&file1); Possible KFS_rc Values KFS_OK The record was read successfully. 27 KFS_EOF There are no more records in the dataset. KFS_Key_Not_Found A record with the specified key did not exist in the database and no record is returned. (i.e. the previous record must be found before the "next" record can be returned) 28 KFS_Replace(fs, area) Replace the record with the specified key. Parameters KFS_FILEINFO *fs A pointer to a KFS file structure. void *area A pointer to a data area containing the record that will replace the record with the specified key in the database. Description Replace the record with the corresponding key in the data- base with the record in area. If the record does not exist in the database, the operation is ignored and a KFS_Key_Not_found is returned. No prior read of the record being replaced must be done. Required Fields KFS_filename Contains the name of an open database. area Contains the record that will replace the one in the database. Example /* Replace a record in a KFS file */ #include <kfs.h> KFS_FILEINFO file1; typedef struct m { int f1; int f2; char mykey[7]; char filler[89]; } MYSTRUCT; MYSTRUCT inarea; strcpy(file1.KFS_filename, "C:\\MYDIR\\NUMFILE.DAT"); KFS_Open(&file1); strcpy(&inarea.mykey, "Oldkey"); /* Note - we would not have to read to replace */ KFS_Read(&file1, (void *)&inarea); inarea.f2 = 77; KFS_Replace(&file1, (void *)&inarea); switch (file1.KFS_rc) { case KFS_Key_Not_Found : printf("Record was not in file"); case KFS_OK: break; default: printf("Error replacing record"); } 29 Possible KFS_rc Values - KFS_OK The record was read successfully. KFS_Key_Not_Found A record with the key specified was not found. The operation is ignored. KFS_File_Error An unknown error occurred when attempting to replace the requested record. 30 Interdependencies of the KFS operations Except for the requirements for opening databases first and closing databases last, there is no specific dependencies between KFS operations. That is, there is no requirement to call a specific function before another function can be called. For example, it is not necessary to read a specific record before replacing it with KFS_Replace. The same is true if you want to delete a record, it is not necessary to read it first. Simi- larly, you can issue a KFS_ReadNext after any other operation, as long as the key of an existing record is present in the data area so that KFS_ReadNext can read the record with the next highest key. 31 Special Processing There are a few special options that may be chosen when creating a database with the Keyed File System that allow for special uses of databases. These options are enabled by setting certain bits in the KFS_flags field of the File Information Structure. If none of the options are desired, the flags field should be set to KFS_Normal_PTR. Normally, databases are relatively large databases (such as customer record databases) with keys that contain primarily letters (people's names, for example) and the Keyed File System was designed to handle these databases most efficiently. Some assumptions are made about the number and type of keys that will exist in the database when it is created and results in creating an initial .PTR file of about 8K bytes. Because of this initial allocation, the .PTR file is normally slow to grow. However, for some applications, the assumptions made by the Keyed File System may not be correct. Three options are provided to enable the programmer to select a more efficient initial .PTR allocation or to utilize various types of keys. KFS_Small_PTR For applications that need relatively small databases (up to a few hundred records), the KFS_Small_PTR option provides a way to greatly reduce the initial size of the .PTR file from 8K to a few hundred bytes. However, using this option will result in slower execution speed if the database does grow large. Note that this does not prohibit the database from becoming large, just that performance is slower should it do so. The option is enabled by setting the KFS_flags field to KFS_Small_PTR. In C this could be done by the following code : #include <kfs.h> KFS_FILEINFO file1; file1.KFS_flags = KFS_Small_PTR; KFS_Numeric_Key For applications whose keys are all numbers, it would be more efficient of these numbers could be stored in the normal way that the Intel 80x86 stores numbers. That is, in byte reversed binary form (ie. short, int, or long in C terminology). The Keyed File System provides the KFS_Numeric_Key option that allows the key to be stored in the 4 byte Intel integer format (ie. C's "long int"). Using this option will cause the system to assume that KFS_keypos indicates the beginning of a 4 byte key that is a number stored in integer form. KFS_keylen is ignored when this option is specified. The option is enabled by setting the KFS_flags field to KFS_Numeric_Key. In C this could be done by the following code : #include <kfs.h> KFS_FILEINFO file1; file1.KFS_flags = KFS_Numeric_Key; 32 KFS_Ignore_Case Normally, databases created with alphabetic keys are sensitive to the case of the keys. That is, keys "ABCDE" and "abcde" indicate the keys of two different records. However, setting this option allows case to be ignored for databases that have alphabetic keys. Then a database created with this option would treat the keys "ABCDE" and "abcde" as the key to the same record. The option can be combined with the KFS_Normal_PTR or KFS_Small_PTR options and is enabled by setting the KFS_flags field to KFS_Ignore_Case. In C this could be done by the fol- lowing code : #include <kfs.h> KFS_FILEINFO file1; file1.KFS_flags = KFS_Normal_PTR | KFS_Ignore_Case; 33 Programming Hints and Tips In this section we will try to provide some hints, examples, and, hopefully, the answers to some questions to help an appli- cation developer in using the Keyed File System. As part of the KFS package we have included the source to the sample and util- ity programs we have provided. These programs will provide some concrete coding examples of how to use the functions we have described. Use them to reinforce some of the examples we use in this section. * Ensure that when creating a database that the KFS_flags field is properly set to one of the valid options. * When specifying a key in the data area for an operation that requires a key, make sure that all bytes in the key field are set to a known value. Remember, the Keyed File System always assumes the key is KFS_keylen bytes long, irrespective of any NULLS in the key field. A common mis- take is not to "clear" the key field before moving in a key that may be shorter than keylen. For example, STRCPY only moves data until a '00'X is detected in the source. Thus, if what is being moved in is shorter than KFS_keylen, the remaining bytes of the key field will remain unchanged (ie. may contain garbage). Additionally, consider that STRCPY also moves the terminating NULL character and that will become part of the key. This may be OK, just realize that the NULL is there. A good habit to get into when using KFS functions is illustrated by the following code: #include <kfs.h> KFS_FILEINFO file1; char area[80]; memset(&area[file1.KFS_keypos], ' ', file1.KFS_keylen); strcpy(&area[file1.KFS_keypos, newkey); This code sequence initially sets the key field of "area" to blanks and then copies in the desired key from the "newkey" variable. * You will notice that the Keyed File System does not allow for duplicate keys. However, with a little thought, the KFS_ReadGen and KFS_ReadNext functions can be used to pro- vide a similar capability. For example, if you wanted to have a database whose key was a name field, duplicate names could be avoided by making the key field the name AND account number. You could still issue a KFS_ReadGen for only the name and then use KFS_ReadNext to read the rest of the records having the same name. * If KFS_ReadNext tries to read the next record after the last logical record in the database (ie. the record with the highest key) a KFS_EOF is returned. If another KFS_ReadNext is issued, KFS_EOF will again be returned. However, other operations (such as KFS_Read) are still allowed on the database and will result in KFS_rc to be set to another value (such as KFS_OK if the read is success- ful). Further KFS_ReadNext operations may be performed from that spot in the database. 34 * We mentioned earlier that numeric and alphabetic keys can- not be combined. However, if you keep in mind that shorts and longs are stored in byte reversed format, you can form keys that mix data types. The following code segment com- bines an alphabetic customer name and a numeric (i.e. long) customer number into a single key. The customers names would be in the database in alphabetic sequence, but cus- tomers with the same name would not necessarily be in sequence by customer number (customer number 256, stored as '00010000'x, would be before customer number 255, stored as 'FF000000'x, for example). #include <kfs.h> struct DA { char custname[40]; long custnum; char morestuff[40]; } myarea; KFS_FILEINFO myfile; : myfile.KFS_keypos = 0; myfile.KFS_keylen = 44; : KFS_Create(&myfile); 35 Data Recovery Most programmers are familiar with damaged data files caused by unusual system problems (power failures or system crashes) while a file is being written to disk. While these problems are rare, they do occur. The Keyed File System contains code that attempts to minimize the impact of such a system failure, but this impact cannot be eliminated completely. Since the Keyed File System uses two related DOS files (an index file and a data file) to manage a database, damage to one of these files can cause the database to become unusable. With a little planning, however, a programmer can frequently recover a damaged KFS database with little or no loss of data. To do this requires a little knowl- edge of the internals of KFS. The data file that makes up a KFS database is a normal DOS binary file. That is, each "logical" record is KFS_recsize bytes long and does not contain a CR/LF at the end of each record. Thus, these records can be read using operating system or C language functions just like any other binary file. Addition- ally, when KFS deletes a record, it is not physically removed from the data file but only from the .PTR file. However, it is marked for reuse and a hex 'FF' is placed in the last byte of the data record when a record is deleted. This hex 'FF' has no consequence to KFS since deleted records are tracked another way internally, but can be useful for a programmer wanting to recover a damaged KFS database by using only the data file. If, when writing an application, a programmer using the Keyed File System ensures that the last byte of each data record cannot normally be hex 'FF', then recovering a KFS database can be relatively simple. A database recovery program can be written that simply reads the data portion of the damaged KFS database as fixed length binary records, checks to ensure the last byte of each record is not hex 'FF' (remember, hex 'FF' means the record has been deleted), and uses the KFS_Add operation to add the record to a new KFS database. At the conclusion of such a recovery program, the new KFS database would contain all of the undamaged records that existed in the original KFS database. A simple example of this technique appears in Appendix B. 36 Appendix A - Keyed File System Return Codes The following is a list of return codes generated by the Keyed File System. These definitions are found in the supplied header file (KFS.H). KFS_OK (0) The operation completed successfully. KFS_Data_File_Open_Error (3) A bad return code was return from the system when trying to open the data file of the database. KFS_EOF (-1) End of file was reached on the data database during a KFS_ReadNext. The database remains open and subsequent keyed operations are allowed. KFS_File_Error (8) An unknown error was returned by the operating system. KFS_File_Already_Exists (9) You are trying to create a database that already exists in this directory. KFS_Invalid_File_Name (1) The database name requested in KFS_filename is longer than the 63 characters allowed by the Keyed File System. KFS_Invalid_Request (11) You are attempting to do a KFS_ReadGen on a database with numeric keys. Use a KFS_ReadGenNumeric function instead. KFS_Key_Already_Exists (4) A record with the key specified already exists in the database. KFS_Key_Length_Invalid (12) The length of the partial key specified for a KFS_ReadGen was either 0 or greater than the key length for this data- base. KFS_Key_Not_Found (5) A record with the key specified does not exist in the database. KFS_Keyed_File_Empty (7) When attempting to execute a KFS_ReadFirst operation it was discovered that the database had no records. KFS_No_Space_On_Disk (13) There is no space on the disk containing the KFS database to add a new record. KFS_Prior_Key_Not_Found (6) The key specified as the prior key in a KFS_ReadNext was not found in the database. 37 KFS_PTR_File_Open_Error (2) A bad return code was return from the system when trying to open the pointer file of the database. KFS_Recordsize_Too_Short (10) The amount specified in KFS_recsize is smaller than KFS_keypos + KFS_keylen. 38 Appendix B - File Recovery Example The following is an example of a C program that could be used to recover a KFS database. Assume the damaged database had the following characteristics: KFS_filename = C:\DATA\MYFILE.DAT KFS_recsize = 100 KFS_keypos = 0 KFS_keylen = 15 The C program to recover this database could look like this: main() { /* Example of how to recover a KFS file if .PTR is damaged */ FILE *old; KFS_FILEINFO new; char dataarea[100]; old = fopen("C:\\DATA\\MYFILE.DAT", "rb"); new.KFS_recsize = 100; new.KFS_keylen = 15; new.KFS_keypos = 0; new.KFS_flags = KFS_Normal_PTR; strcpy(new.KFS_filename, "C:\\WORK\\MYFILE.DAT"); KFS_Create(&new); fread(&dataarea, sizeof(dataarea), 1, old); while(!feof(old)) { if (dataarea[new.KFS_recsize - 1] != 0xff) KFS_Add(&new, &dataarea); fread(&dataarea, sizeof(dataarea), 1, old); } fclose(old); KFS_Close(&new); } 39